/**
 * 注意：不需要挂在场景节点上，可以全局调用
 * 
 * 使用说明：一些数字相关的常用函数合集
 */
var GNum = {
    //***  将大数值转换为自定义单位制下对应的字符串  ***//
    /**进制单位*/
    getNumUnit() {
        if (!this.unit) {
            this.unit = ["K", "M", "B", "T"];
            for (var i = 0; i < 26; i++) {
                var left = String.fromCharCode("A".charCodeAt() + i);
                for (var m = 0; m < 26; m++) {
                    var right = String.fromCharCode("A".charCodeAt() + m);
                    var comb = left + right;
                    this.unit.push(comb);
                }
            }
        }
        return this.unit;
    },

    /**=> 最多保留6位数字   如：99,999.9AB  返回变换后的字符串*/
    num2String6(num) {
        if (num < 1000000) {
            return this.numTo6(num);
        } else {//超过1M，开始显示字母的进制
            var numUnitArr = this.getNumUnit();
            var numLength = Math.round(num).toString().length;//5000 000 000 000 000  16
            var remainder = numLength % 3;//1

            if (remainder === 0) {
                remainder = 3;
            }
            var carry = Math.round((numLength - remainder) / 3) - 1;//1
            var ab = numUnitArr[carry - 1];
            var left = num / (Math.pow(10, 3 * carry));//12345.678
            left = this.numTo6(left);
            return left + ab;
        }
    },

    numTo6(num) {//显示6位
        if (num < 1000000) {
            if (num < 1000) {//最多3位小数
                num = this.fix(num, 3);
            } else {//>= 1000 1000--10000 2  10000--100000 1
                //超过1000显示逗号
                var point = "";
                if (num < 10000) {
                    point = Math.round(num * 100) % 100;
                    if (point < 10 && point != 0) {
                        point = "0" + point;
                    }
                } else if (num < 100000) {
                    point = Math.round(num * 10) % 10;
                }
                num = Math.floor(num);
                var n1 = Math.floor(num / 1000);
                var n2 = num % 1000;
                if (n2 < 10) {
                    n2 = "00" + n2;
                } else if (n2 < 100) {
                    n2 = "0" + n2;
                }
                if (point) {
                    num = n1 + "," + n2 + "." + point;
                } else {
                    num = n1 + "," + n2;
                }
            }
            return num;
        } else {
            console.error("超出6位");
        }
    },

    /**数字转换为千分位字符 */
    formatThousands(num) {
        if (num == undefined) {
            return;
        }
        let str = num.toString();
        let res = str.replace(/\d{1,3}(?=(\d{3})+$)/g, function (s) {
            return s + ','
        });

        return res;
    },

    /**保留指定位数的小数（不强制）0会自动省去  fixTo 要保留的小数位数*/
    fix(num, fixTo) {
        var exp = Math.pow(10, fixTo);
        num = Math.round(num * exp) / exp;
        return num;
    },

    /**保留指定位数的小数（强制）0不会自动省去  fixTo 要保留的小数位数*/
    fixForce(num, fixTo) {
        var exp = Math.pow(10, fixTo);
        num = Math.round(num * exp) / exp;
        num = num.toFixed(fixTo);
        return num;
    },

    //***  随机取值  ***//
    /**随机一个范围 min~max 的整数  
    min为一个整数或者为一个2元素的数组, max为整数或者没有*/
    randomInt(min, max) {
        if (max === undefined) {
            max = min[1];
            min = min[0];
        }
        return Math.floor(Math.random() * (max - min + 1)) + min;
    },

    /**随机-1到1的小数*/
    random_1To1() {
        return 2 * Math.random() - 1;
    },

    /**随机一个范围 min~max 的小数*/
    random(min, max) {
        var ratio = Math.random();
        return min + (max - min) * ratio;
    },

    /**从min--max里面随机选出num个不放回的数，返回这些数组成的数组*/
    randomArr(min, max, num) {
        if (num > (max - min + 1)) {
            console.error("取数个数大于可取个数！！！");
            return;
        }
        //目标数组
        var targetArr = [];
        //取得的数组
        var getArr = [];
        for (var i = min; i <= max; i++) {
            targetArr.push(i);
        }
        for (var n = 0; n < num; n++) {
            var randomNum = this.randomInt(0, targetArr.length - 1);
            getArr.push(targetArr[randomNum]);
            targetArr.splice(randomNum, 1);
        }
        return getArr;
    },


    //***  将秒数时间转换成电子手表的表示形式  ***//
    /** 将秒数变成 min:sencond 的形式显示  如 179 => 02:59 */
    showTimeTableMin(time) {
        //四舍五入取整
        time = Math.round(time);
        var timeTable = "";
        var min = Math.floor(time / 60);
        var sencond = time % 60;
        if (min < 10) {
            min = "0" + min;
        }
        if (sencond < 10) {
            sencond = "0" + sencond;
        }
        timeTable = min + ":" + sencond;
        return timeTable;
    },

    /** 将秒数变成 hour:min:sencond 的形式显示  如 3601 => 01:00:01 */
    showTimeTableHour(time) {
        //四舍五入取整
        time = Math.round(time);
        var timeTable = "";
        var hour = Math.floor(time / 3600);
        var left = time % 3600;
        var min = Math.floor(left / 60);
        var sencond = left % 60;
        if (hour < 10) {
            hour = "0" + hour;
        }
        if (min < 10) {
            min = "0" + min;
        }
        if (sencond < 10) {
            sencond = "0" + sencond;
        }
        timeTable = hour + ":" + min + ":" + sencond;
        return timeTable;
    },

    /**找到一个数字在一个数组分割中的位置索引 index 小于等于就返回，  
     * 找不到，如果 cut1 就返回 arr.length - 1, 否则返回 arr.length  
     * num 要查找的数字  
     * arr 目标数组  
     * cut1 是否 -1
     */
    getNumIndexInArr(num, arr, cut1) {
        for (var i = 0; i < arr.length; i++) {
            if (num <= arr[i]) {
                return i;
            }
        }
        if (cut1) {
            return arr.length - 1;
        } else {
            return arr.length;
        }
    },

    /**将一个数组依次累加后返回 */
    getAddArr(arr) {
        var AddArr = [];
        AddArr.push(arr[0]);
        for (var i = 1; i < arr.length; i++) {
            AddArr.push(AddArr[i - 1] + arr[i]);
        }
        return AddArr;
    },

    /**求最大值  
     * 参数可以为数值，数组，或者两者都有 数组为1维数组
     */
    max() {
        //取出所有的数
        var arr = [];
        var max = 0;
        for (var i = 0; i < arguments.length; i++) {
            if (typeof arguments[i] == "number") {
                arr.push(arguments[i]);
            } else if (Array.isArray(arguments[i])) {
                for (var m = 0; m < arguments[i].length; m++) {
                    if (typeof arguments[i][m] == "number") {
                        arr.push(arguments[i][m]);
                    }
                }
            }
        }
        for (var t = 0; t < arr.length; t++) {
            max = max < arr[t] ? arr[t] : max;
        }
        return max;
    },

    /**一个数字是否在给定的数组中 存在就返回对应的顺序 index  否则返回 -1  
     * num 要检查的数字  
     * arr 要检查的数组
    */
    isNumExistInArr(num, arr) {
        for (var i = 0; i < arr.length; i++) {
            if (num === arr[i]) {
                return i;
            }
        }
        return -1;
    },

    /**限制一个数的范围  
     * num 要限制的数  
     * range 限制的范围或下限 为一个2维数组或者一个数 必须  
     * up 限制的上限，可选
     */
    clamp(num, range, up) {
        if (Array.isArray(range)) {
            if (range.length === 2) {
                up = range[1];
                range = range[0];
            } else {
                console.error("限制的范围错误！！！");
            }
        }
        num = num < range ? range : num;
        num = num > up ? up : num;
        return num;
    },

    /**取出一个字符串里面的整数数字 */
    getNumInString(string) {
        if (!string) {
            return;
        }
        var num = "";
        for (var i = 0; i < string.length; i++) {
            if (!isNaN(string[i])) {
                num += string[i];
            }
        }
        return parseInt(num);
    },

    /**从一个数组中随机（可放回）取值，取一个返回数本身， 取多个则返回这些数组成的数组  
     * arr 要取值的数组  
     * num 取值的个数，默认为1，可选
     */
    getRandomInArr(arr, num) {
        num = num || 1;
        var getArr = [];
        for (var i = 0; i < num; i++) {
            var randomInt = this.randomInt([0, arr.length - 1]);
            getArr.push(arr[randomInt]);
        }
        if (getArr.length === 1) {
            return getArr[0];
        }
        return getArr;
    },

    /**去掉数组的空位 */
    filterEmptyInArr(arr) {
        var newArr = [];
        arr.forEach(element => {
            newArr.push(element);
        });
        return newArr;
    },

    /**复制一个数组  返回复制后的数组
    * @param {Array} fromArr 要复制的数组  
    */
    cloneArr(fromArr) {
        var toArr = [];
        for (var i = 0; i < fromArr.length; i++) {
            if (Array.isArray(fromArr[i])) {
                toArr.push(this.cloneArr(fromArr[i]));
            } else {
                toArr.push(fromArr[i]);
            }
        }
        return toArr;
    },

    /**返回一个数组一定比例的元素组成的数组 */
    getPartInArr(arr, part) {
        var getPart = [];
        var minIndex = arr.length * part;
        minIndex = Math.ceil(minIndex);
        for (var i = minIndex; i < arr.length; i++) {
            getPart.push(arr[i]);
        }
        return getPart;
    },

    /**获取一个数组总元素个数 */
    getArrTotalLength(arr) {
        var totalLength = 0;
        for (var i = 0; i < arr.length; i++) {
            if (Array.isArray(arr[i])) {
                totalLength += this.getArrTotalLength(arr[i]);
            } else {
                totalLength++;
            }
        }
        return totalLength;
    },

    /**获取数组中满足一定条件的元素  
     * 纯数字数组找到了返回 true, 否则返回 false   对象数组找到了返回对象，否则返回null  
     * condition 要查找的条件  
     * arr 查找的目标数组  
     * key 目标数组的查找字段，对象数组必选，数字数组没有  
     * saveName 存储名字，用于标记查找 对象数组必选，数字数组没有  
    */
    getExistInArr(condition, arr, key, saveName) {
        if (key) {//对象数组
            if (!this[saveName]) {
                this[saveName] = {};
                //便利数组，将其中的信息保存下来
                for (var i = 0; i < arr.length; i++) {
                    this[saveName][key + arr[i][key]] = arr[i];
                }
            }
            return this[saveName][key + condition] || null;
        } else {//纯数字数组
            for (var i = 0; i < arr.length; i++) {
                if (arr[i] === condition) {
                    return true;
                }
            }
            return false;
        }
    },

    /**将一个概率数组的前面几项扩大处理，整体和仍为1， 
     * arr 要处理的数组  
     * expands 扩大的倍数  
     * num 前面几项
    */
    arrExpand(arr, expands, num) {
        var total = 0;
        var arrGet = this.cloneArr(arr);
        for (var i = 0; i < arrGet.length; i++) {
            if (i < num) {
                arrGet[i] *= expands;
            }
            total += arrGet[i];
        }
        for (var i = 0; i < arrGet.length; i++) {
            arrGet[i] /= total;
        }
        return arrGet;
    },

    /**
     * 加上计量单位 K M B T   
     * number  
     * fix: 保留小数位
     */
    numToKMBT(number, fix) {
        var suffix_arr = ["", "K", "M", "B"];
        var value = number;
        var i = 0;
        while (value >= 1000) {
            value /= 1000;
            i++;
        }
        if (fix >= 0) {
            value = value.toFixed(fix);
        }
        return suffix_arr[i] ? value + suffix_arr[i] : number + "";
    },

    /**
     * 保留len长度的整数
     */
    numToKMBT2(number, len) {
        var suffix_arr = ["", "K", "M", "B"];
        var value = number;
        var i = 0;
        while ((parseInt(value)).toString().length > len && value >= 1000) {
            value /= 1000;
            value = parseFloat(value.toFixed(10));
            i++;
        }
        // if (fix == undefined) fix = 0;
        // if (fix >= 0) {
        //     value = value.toFixed(fix);
        // }
        value = parseInt(value);
        return suffix_arr[i] ? value + suffix_arr[i] : number + "";
    },

    /**随机获得一个mac地址 */
    getMAC() {
        var hexDigits = "0123456789ABCDEF";
        var macAddress = "";
        for (var i = 0; i < 6; i++) {
            macAddress += hexDigits.charAt(this.randomInt(0, 15));
            macAddress += hexDigits.charAt(this.randomInt(0, 15));
            if (i != 5) macAddress += ":";
        }
        return macAddress;
    },

    /**两个日期是否在同一天  
     * day1 要比较的日期1毫秒数  
     * day2 要比较的日期2毫秒数 默认为今天 
     */
    isSameDay(day1, day2 = Date.now()) {
        return new Date(day1).toDateString() === new Date(day2).toDateString();
    },

    /**将毫秒时间转换成格式化的时间 如：2019.5.22 18:31  
     * time 毫秒时间数  1558520800310   
     * spliceType 分隔类型 如 “-” "." “_” 可选  默认为 "."  
     * isHide 今天的日期是否隐藏 年 月 日 
    */
    timeFormat(time, spliceType, isHide) {
        spliceType = spliceType || ".";
        var out = "";
        var date = new Date(time);
        if (!isHide || !this.isSameDay(time)) {
            //获取参数 年月日
            var year = date.getFullYear();
            out += year;
            var month = date.getMonth() + 1;
            month = month < 10 ? "0" + month : month;
            var day = date.getDate();
            day = day < 10 ? "0" + day : day;
            out += spliceType + month;
            out += spliceType + day;
            out += " ";
        }
        //获取 时分
        var hours = date.getHours();
        hours = hours < 10 ? "0" + hours : hours;
        out += hours;
        var min = date.getMinutes();
        min = min < 10 ? "0" + min : min;
        out += ":" + min;
        return out;
    },

    /**将毫秒时间转换成 年月日时分秒 的数字字符返回  
     * time 毫秒时间数 默认当前时间  1558520800310   
     * spliceType 分隔类型 如 “-” "." “_” 可选  默认为 ""  
     */
    suiteTime(time = Date.now(), spliceType = "") {
        var out = "";
        var date = new Date(time);
        //年月日
        var year = date.getFullYear();
        out += year;
        var month = date.getMonth() + 1;
        month = month < 10 ? "0" + month : month;
        var day = date.getDate();
        day = day < 10 ? "0" + day : day;
        out += spliceType + month;
        out += spliceType + day;
        //时分秒
        var hours = date.getHours();
        hours = hours < 10 ? "0" + hours : hours;
        out += spliceType + hours;
        var min = date.getMinutes();
        min = min < 10 ? "0" + min : min;
        out += spliceType + min;
        var sencond = date.getSeconds();
        sencond = sencond < 10 ? "0" + sencond : sencond;
        out += spliceType + sencond;
        return out;
    },

    /**从一个数组中随机选 num 项(每项各不相同)组成数组返回 */
    getRandomDiffInArr(arr, num = 1) {
        var getArr = [];
        var arr1 = JSON.parse(JSON.stringify(arr));
        for (var i = 0; i < num; i++) {
            var randomInt = this.randomInt([0, arr1.length - 1]);
            getArr.push(arr1.splice(randomInt, 1)[0]);
        }
        return getArr;
    },

    /**格式化当前时间 */
    formatCurTime() {
        let date = new Date(Date.now());
        let time = date.getHours() + ":" + date.getMinutes() + ":" + date.getSeconds() + "." + date.getMilliseconds();
        return time;
    },

    isFloat(n) {
        if (isNaN(n)) {
            return false;
        }
        return n != parseInt(n);
    }
};

window.GNum = GNum;



